/*
 ============================================================================
 Name        : PPD.c
 Author      : SOogle
 Version     : 1.0
 Copyright   : All rights reserved
 Description : FUSELAGE - FUSE FAT32 FILE SYSTEM
 ============================================================================
 */


#include "../headers/GlobalHeader.h"

struct_config configuracion;
PPD_CHS posicionActualCabezal, proximoSectorPlanifico, posicionAnterior;
int32_t filesize;
t_Cola *colaPedidos, *colaActiva;
pthread_mutex_t mutexCola, mutexArchivoMapeado, mutexCabezalActual;
int32_t SUBIENDO;
int32_t modoInicio, algoritmoUtilizado;
int32_t sizeCola, sizeColaActiva;
extern t_log *logger;
char *handlerArchivoMapeado;
int32_t cantidadClientesPFS = 0;
NodoPFS *listaPFS;
t_nodoCola *listaNATrabajar = NULL;
int32_t N;
int32_t discoEstaSubiendo = 1;

int main(void)
{
	pthread_t thread_lectorPedidos_pfs_id, thread_lectorPedidos_raid_id, thread_lectorPedidos_consola_id, thread_msync_id;
	int32_t addrlen = sizeof(struct sockaddr_in);
	int32_t cliente_ppd = socket(AF_INET,SOCK_STREAM,0);
	int32_t rc;
	nipc paquete_mando, paquete_recibo;
	struct_thread_lector struct_thread_lector;
	t_pedido pedidoPlanificacion;
	int32_t *colaLog;

	//CARGO LA CONFIGURACION INICIAL
	configuracion = cargaConfiguracionInicial();

	//INICIALIZO LAS ESTRUCTURAS
	inicializarEstructuras();

	printf("!!!Hola soy el PPD: %s \n",configuracion.DiscoID);
	printf("\n");

	if (configuracion.LogActivado == 1)
	{
		log_info(logger, "PPD - MAIN", "Se cargo exitosamente el archivo de configuracion\n");
	}

	//CREO LA COLA DE PEDIDOS
	colaPedidos = crearCola();
	if (configuracion.LogActivado == 1)
	{
		log_info(logger, "PPD - MAIN", "Se creo exitosamente la cola de pedidos\n");
	}


	//CREO THREAD DE SINCRONIZACION
	pthread_create(&thread_msync_id,NULL,(void*)&thread_msync,NULL);

	//INICIO SEMAFOROS Y MUTEX
	pthread_mutex_init (&mutexArchivoMapeado, NULL);
	pthread_mutex_init(&mutexCola, NULL);
	pthread_mutex_init (&mutexCabezalActual, NULL);

	//CARGO EL STRUCT DIRECCION LOCAL Y REMOTA
	struct sockaddr_in *direccion_local = malloc(sizeof(struct sockaddr_in));
	struct sockaddr_in *direccion_remota = malloc(sizeof(struct sockaddr_in));

	//CREO THREAD DE LECTOR DE PEDIDOS DE CONSOLA, EL CUAL ES UTILIZADO TANTO POR LISTEN COMO POR CONNECT
	pthread_create(&thread_lectorPedidos_consola_id,NULL,(void *)&thread_lector_consola,NULL);

	switch(modoInicio)
	{
		case CONNECT:

			direccion_local->sin_family = AF_INET;
			direccion_local->sin_addr.s_addr = INADDR_ANY;
			direccion_local->sin_port = htons(configuracion.PuertoEscuchaPpd);

			direccion_remota->sin_family = AF_INET;
			direccion_remota->sin_addr.s_addr = inet_addr(configuracion.IPRaid);
			direccion_remota->sin_port = htons(configuracion.PuertoRaid);

			rc = connect(cliente_ppd,(struct sockaddr *)direccion_remota,addrlen);
			if (rc < 0)
			{
				//LOGUEO EL ERROR DE CONNECT
				if (configuracion.LogActivado==1)
					log_error(logger, "MAIN", "%s: Error al intentar conectarse al RAID a traves del socket %i \n", cliente_ppd);
				close(cliente_ppd);
				cerrarArchivo();
				exit(1);
			}

			if (configuracion.LogActivado==1)
				log_info(logger, "MAIN", "Se conecto el RAID a traves del socket: %i \n", cliente_ppd);

			//PREPARO EL HANDSHAKE
			paquete_mando.type = 0;
			paquete_mando.payloadlength = sizeof(t_pedido);
			strcpy(paquete_mando.payload.planificador_id,configuracion.DiscoID);
			paquete_mando.payload.direccionSector = cantidadTotalDeSectores();

			rc = send(cliente_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
			if (rc < 0)
			{
				if (configuracion.LogActivado == 1)
					log_error(logger, "MAIN", "Error al enviar Handshake \n");
				cerrarArchivo();
				exit(1);
			}
			if (configuracion.LogActivado == 1)
				log_info(logger, "MAIN", "Se mando handshake \n");

			rc = recv(cliente_ppd,&paquete_recibo,sizeof(nipc),MSG_WAITALL);
			if (rc < 0)
			{
				if (configuracion.LogActivado == 1)
					log_error(logger, "MAIN", "Error al recibir handshake \n");
				exit (1);
			}

			if(paquete_recibo.payloadlength == 0)
			{
				struct_thread_lector.socket_id = cliente_ppd;
				if (configuracion.LogActivado == 1)
					log_info(logger, "MAIN", "Se recibio el handshake correctamente \n");
			}

			pthread_create(&thread_lectorPedidos_raid_id,NULL,(void*)&thread_lector_pedidos_raid,(void *)&struct_thread_lector);

			switch(algoritmoUtilizado)
			{
				case CON_INANICION:

					while(TRUE)
					{

						pthread_mutex_lock (&mutexCola);
						sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
						//MIENTRAS HAYA PEDIDOS EN LA COLA, LOS VOY A PROCESAR
						pthread_mutex_unlock (&mutexCola);
						//puts("1");
						if ((sizeCola > 0) && (colaPedidos->frente!=NULL))
						{

						//	puts("2");				//PIDO LOS SECTORES DE LA COLA PARA LOGUEARLOS
							//BLOQUEO LA LISTA PARA PODER TRABAJAR
							pthread_mutex_lock (&mutexCola);
							sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
							//SACO UN PEDIDO DE LA COLA PARA PROCESARLO, ACA LA FUNCION SE LLAMARIA TOMOPEDIDO();
							if(configuracion.LogActivado == 1)
							{
								colaLog = armarColaLogueoSSTF();
							}
							pedidoPlanificacion = quitarPedido_SSTF();
							sem_wait(&(colaPedidos->cantidadPedidos));
							pthread_mutex_unlock(&mutexCola);
							//UNA VEZ QUE TOME EL PEDIDO, YA PUEDO LIBERAR LA COLA PARA QUE SE AGREGUEN MAS PEDIDOS DE LOS OTROS THREADS
							//TENGO QUE VER EL TIPO DE PEDIDO, SI ES DE CONSOLA O SI ES DE PFS
							switch(pedidoPlanificacion.conexion_pfs_id)
							{
								case PEDIDO_CONSOLA:
									//SI ES DE CONSOLA, PROCESO Y AVISO QUE FUE PROCESADO ASI PUEDO DEVOLVER POR STDOUT
									//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
									paquete_mando = procesoPedidoElegido(pedidoPlanificacion, colaLog);
									//free(colaLog);
									switch (pedidoPlanificacion.lectura_o_escritura)
									{
										case 'L' : //sos trace
											enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
											break;

										case 'E' : //sos clean
											enviaRespuestaCLEAN(paquete_mando.type);
											if (configuracion.LogActivado == 1)
												log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
											break;
									}

									break;

										default:
											//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
											//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
											paquete_mando = procesoPedidoElegido(pedidoPlanificacion, colaLog);
											//free(colaLog);

											send(cliente_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
											//printf("procese %i de %c ;;",paquete_mando.payload.direccionSector,paquete_mando.payload.lectura_o_escritura);
											if (configuracion.LogActivado == 1)
												log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
											break;
							}
						}
					}
					break;

				case SIN_INANICION:

					while(TRUE)
					{
						sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);

						if (sizeCola > 0)
						{

							N=0;
							pthread_mutex_lock (&mutexCola);
							listaNATrabajar=NULL;
							agarroNPedidos(&listaNATrabajar,&N);

							pthread_mutex_unlock (&mutexCola);

							while(N>0){

									if(listaNATrabajar != NULL){
									sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
									pthread_mutex_lock (&mutexCola);
									if (configuracion.LogActivado == 1)
										colaLog = armarColaLogueoSSTF();

									pedidoPlanificacion = ppd_nstepScan(N);

									pthread_mutex_unlock (&mutexCola);

									//sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
									N--;
									switch(pedidoPlanificacion.conexion_pfs_id)
									{
									case PEDIDO_CONSOLA:

										paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLog, N);

										if (configuracion.LogActivado == 1)
											free(colaLog);
										switch (pedidoPlanificacion.lectura_o_escritura)
										{
										case 'L' : //sos trace
											enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
											if (configuracion.LogActivado == 1)
												log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
											break;

										case 'E' : //sos clean
											enviaRespuestaCLEAN(paquete_mando.type);
											if (configuracion.LogActivado == 1)
												log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
											break;
										}
										break;
										default:
											//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
											//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
											//paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N - var2 -1);
											paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLog, N);
											if (configuracion.LogActivado == 1)
												free(colaLog);
											//puts("me quede en un send");
											send(cliente_ppd,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
											if (configuracion.LogActivado == 1)
												log_info(logger, "MAIN", "Se envio la respuesta del pedido de %c sobre el sector %d:%d correctamente \n",paquete_mando.payload.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);
											//printf(" <%i> ", paquete_mando.payload.direccionSector);
											break;
									}
								}
							}
						}
					}
					break;
			}

			break;

				case LISTEN:

					pthread_create(&thread_lectorPedidos_pfs_id,NULL,(void*)&thread_lector_pedidos_pfs,NULL);

					switch(algoritmoUtilizado)
					{
						case CON_INANICION:

							while(TRUE)
							{
								pthread_mutex_lock (&mutexCola);
								sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
								//MIENTRAS HAYA PEDIDOS EN LA COLA, LOS VOY A PROCESAR
								pthread_mutex_unlock (&mutexCola);
								//puts("1");
								if ((sizeCola > 0) && (colaPedidos->frente!=NULL))
								{
									//PIDO LOS SECTORES DE LA COLA PARA LOGUEARLOS
									//BLOQUEO LA LISTA PARA PODER TRABAJAR
									pthread_mutex_lock (&mutexCola);
									//SACO UN PEDIDO DE LA COLA PARA PROCESARLO, ACA LA FUNCION SE LLAMARIA TOMOPEDIDO();
									if(configuracion.LogActivado == 1)
									{
										colaLog = armarColaLogueoSSTF();
									}
									pedidoPlanificacion = quitarPedido_SSTF();
									sem_wait(&(colaPedidos->cantidadPedidos));
									pthread_mutex_unlock(&mutexCola);
									//UNA VEZ QUE TOME EL PEDIDO, YA PUEDO LIBERAR LA COLA PARA QUE SE AGREGUEN MAS PEDIDOS DE LOS OTROS THREADS
									//TENGO QUE VER EL TIPO DE PEDIDO, SI ES DE CONSOLA O SI ES DE PFS
									switch(pedidoPlanificacion.conexion_pfs_id)
									{
										case PEDIDO_CONSOLA:
											//SI ES DE CONSOLA, PROCESO Y AVISO QUE FUE PROCESADO ASI PUEDO DEVOLVER POR STDOUT
											//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
											paquete_mando = procesoPedidoElegido(pedidoPlanificacion, colaLog);

											if(configuracion.LogActivado)free(colaLog);
											//free(colaLog);
											switch (pedidoPlanificacion.lectura_o_escritura)
											{
												case 'L' : //sos trace
													enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
													break;

												case 'E' : //sos clean
													enviaRespuestaCLEAN(paquete_mando.type);
													if (configuracion.LogActivado == 1)
														log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
													break;
											}

											break;

												default:
													//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
													//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
													paquete_mando = procesoPedidoElegido(pedidoPlanificacion, colaLog);
													if(configuracion.LogActivado)free(colaLog);//free(colaLog);

													send(pedidoPlanificacion.conexion_pfs_id,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);

													if (configuracion.LogActivado == 1)
														log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
													break;
									}
								}
							}
							break;

						case SIN_INANICION:

							while(TRUE)
							{
								sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);

								if (sizeCola > 0)
								{

									N=0;
									pthread_mutex_lock (&mutexCola);
									listaNATrabajar=NULL;
									agarroNPedidos(&listaNATrabajar,&N);

									pthread_mutex_unlock (&mutexCola);

									while(N>0){

									if(listaNATrabajar != NULL){
										sem_getvalue(&(colaPedidos->cantidadPedidos), &sizeCola);
											pthread_mutex_lock (&mutexCola);
											if (configuracion.LogActivado == 1)
												colaLog = armarColaLogueoSSTF();

											pedidoPlanificacion = ppd_nstepScan(N);

											pthread_mutex_unlock (&mutexCola);

											N--;
											switch(pedidoPlanificacion.conexion_pfs_id)
											{
											case PEDIDO_CONSOLA:

												paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLog, N);

												if (configuracion.LogActivado == 1)
													free(colaLog);
												switch (pedidoPlanificacion.lectura_o_escritura)
												{
												case 'L' : //sos trace
													enviaRespuestaTRACE(posicionActualCabezal, posicionAnterior, pedidoPlanificacion.direccionSector);
													if (configuracion.LogActivado == 1)
														log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
													break;

												case 'E' : //sos clean
													enviaRespuestaCLEAN(paquete_mando.type);
													if (configuracion.LogActivado == 1)
														log_info(logger, "MAIN", "Se envio la respuesta del pedido de E sobre el sector %d:%d correctamente \n", posicionActualCabezal.cylinder, posicionActualCabezal.sector);
													break;
												}
												break;
												default:
													//SI ES DE PFS, O SEA, SI ES DISTRIBUIDO POR EL RAID
													//DENTRO DE ESTA FUNCION, DEBE ESTAR LA ENCARGADA DE LEER Y ESCRIBIR EN DISCO
													//paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLogueo, N - var2 -1);
													paquete_mando = procesoPedidoNSTEPSCAN(pedidoPlanificacion, colaLog, N);
													if (configuracion.LogActivado == 1)
														free(colaLog);
													//puts("me quede en un send");
													send(pedidoPlanificacion.conexion_pfs_id,&paquete_mando,sizeof(nipc),MSG_NOSIGNAL);
													if (configuracion.LogActivado == 1)
														log_info(logger, "MAIN", "Se envio la respuesta del pedido de %c sobre el sector %d:%d correctamente \n",paquete_mando.payload.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);
													//printf(" <%i> ", paquete_mando.payload.direccionSector);
													break;

										}
									}
								}
							}
					}
break;
	}
	}
	destruirCola(colaPedidos);
	close(cliente_ppd);

	return EXIT_SUCCESS;
}

void agarroNPedidos(t_nodoCola ** listaNATrabajar1,int32_t *J){

	*listaNATrabajar1 = colaPedidos->frente;
	t_nodoCola * aux = NULL;
	aux = colaPedidos->frente;
	(*J) = 0;
	int32_t var1;
	for (var1 = 1; var1 <= configuracion.tamanioListaScan; var1++) {

		if(aux != NULL){

			aux = aux->siguiente;
			(*J)++;
		}

	}
	//aux->siguiente = NULL;

}

t_pedido ppd_nstepScan(int32_t N){

	t_pedido elegido;
	int32_t actual;

	pthread_mutex_lock (&mutexCabezalActual);
	actual=ppd_CHStoLBA(posicionActualCabezal);
	pthread_mutex_unlock (&mutexCabezalActual);

	if( N == 1){
		elegido = listaNATrabajar->pedido;

		borrarPedidoProcesado(&listaNATrabajar,listaNATrabajar->pedido);

		sem_wait(&(colaPedidos->cantidadPedidos));

		if(elegido.direccionSector<actual){
			discoEstaSubiendo=0;
		}else{
			if(elegido.direccionSector>actual){
				discoEstaSubiendo=1;
			}
		}


		return elegido;
	}else{

		elegido=mejorNstep(listaNATrabajar,N);
		borrarPedidoProcesado(&listaNATrabajar,elegido);

		sem_wait(&(colaPedidos->cantidadPedidos));

		if(elegido.direccionSector<actual){
			discoEstaSubiendo=0;
		}else{
			if(elegido.direccionSector>actual){
				discoEstaSubiendo=1;
			}
		}

		return elegido;
	}



}

nipc procesoPedidoNSTEPSCAN(t_pedido pedidoPorProcesar, int32_t *colaLoguear, int32_t N)
{
	nipc nipcConsola = armoNIPC(pedidoPorProcesar);
	t_pedido pedido;


	if(N>0 && listaNATrabajar != NULL){
		pthread_mutex_lock (&mutexCola);
		pedido = ppd_nstepScanProximoSector(N);
		proximoSectorPlanifico = ppd_LBAToCHS(pedido.direccionSector);
		pthread_mutex_unlock(&mutexCola);
	}

	if (configuracion.LogActivado == 1)
	logueoInformacionProceso(pedidoPorProcesar, colaLoguear);

	pthread_mutex_lock (&mutexCabezalActual);
	posicionAnterior = posicionActualCabezal;
	posicionActualCabezal = ppd_LBAToCHS(pedidoPorProcesar.direccionSector);
	pthread_mutex_unlock (&mutexCabezalActual);
	if (configuracion.LogActivado == 1)
	log_info(logger, "MAIN", "Se proceso el pedido de %c sobre el sector %d:%d correctamente \n", pedidoPorProcesar.lectura_o_escritura, posicionActualCabezal.cylinder, posicionActualCabezal.sector);

	return nipcConsola;
}

t_pedido ppd_nstepScanProximoSector(int32_t N)
{
		t_pedido elegido;
		int32_t actual;
		elegido.direccionSector=0;
		pthread_mutex_lock (&mutexCabezalActual);
		actual=ppd_CHStoLBA(posicionActualCabezal);
		pthread_mutex_unlock (&mutexCabezalActual);

	/*	if( N == 1){
			elegido = listaNATrabajar->pedido;

				if(elegido.direccionSector<actual){
					discoEstaSubiendo=0;
				}else{
					if(elegido.direccionSector>actual){
						discoEstaSubiendo=1;
					}
				}
				return elegido;

		}else{*/
//			if(N==1){
//		elegido=mejorNstep(colaPedidos->frente,configuracion.tamanioListaScan);
//			}else{
			if(N==0){
		elegido=mejorNstep(colaPedidos->frente,configuracion.tamanioListaScan);
				}else
		elegido=mejorNstep(listaNATrabajar,N);
			//}

			if(elegido.direccionSector<actual){
				discoEstaSubiendo=0;
			}else{
				if(elegido.direccionSector>actual){
					discoEstaSubiendo=1;
				}
			}

			return elegido;
/*}
		return elegido;*/
}

t_pedido mejorNstep(t_nodoCola * lstATrabajar, int32_t N){


	t_nodoCola *aux=NULL;
	t_nodoCola *mejor=NULL;
	t_pedido mejorPedido;
	PPD_CHS mejorSector,auxSector;

	mejor=NULL;

	int32_t posicionActual;
	int32_t cambioSentido=0;

	pthread_mutex_lock (&mutexCabezalActual);
	posicionActual=ppd_CHStoLBA(posicionActualCabezal);
	pthread_mutex_unlock (&mutexCabezalActual);
	int32_t var =0;

	while(cambioSentido==0){
		var =0;
		cambioSentido++;

		if(discoEstaSubiendo==1){
			aux =lstATrabajar;
			while((var<N) && aux!=NULL){

				if(aux->pedido.direccionSector >= posicionActual){
					//Es la primera vez que entra
					if(mejor==NULL){

						mejor=aux;
						mejorSector=ppd_LBAToCHS(aux->pedido.direccionSector);

					}else{

						auxSector=ppd_LBAToCHS(aux->pedido.direccionSector);
							//Debo fijarme el sentido del movimiento
						if( (auxSector.cylinder<=mejorSector.cylinder) && (auxSector.sector<mejorSector.sector)){
									mejor=aux;
									mejorSector=ppd_LBAToCHS(aux->pedido.direccionSector);
								}

					}
				}

				aux=aux->siguiente;
				var++;
			}
			if(mejor==NULL){
				cambioSentido--;
				discoEstaSubiendo=0;
			}

		}else{
			aux =lstATrabajar;
			//Disco baja
			while((var<N) && aux!=NULL){

				if(aux->pedido.direccionSector <= posicionActual){

				if(mejor==NULL){

					mejor=aux;
					mejorSector=ppd_LBAToCHS(aux->pedido.direccionSector);

				}else{
					auxSector=ppd_LBAToCHS(aux->pedido.direccionSector);
					//Misma pista
					if( (auxSector.cylinder>= mejorSector.cylinder)&&(auxSector.sector>mejorSector.sector)){

							mejor=aux;
							mejorSector=ppd_LBAToCHS(aux->pedido.direccionSector);

						}

					}
				}
				var++;
				aux=aux->siguiente;
			}

			if(mejor==NULL){
				cambioSentido--;
				discoEstaSubiendo=1;
			}

		}
	}

	mejorPedido=mejor->pedido;

	return mejorPedido;
}

void borrarPedidoProcesado(t_nodoCola **lst, t_pedido structObtenido) {
	t_nodoCola * aux, *anterior;
	int32_t comparacion_string;

	anterior = NULL;

	for (aux = *lst; aux != NULL; anterior = aux, aux = aux->siguiente) {

		comparacion_string = strcmp(aux->pedido.planificador_id,structObtenido.planificador_id);
		if (((aux->pedido.direccionSector == structObtenido.direccionSector) && (aux->pedido.conexion_ppd_id == structObtenido.conexion_ppd_id)
				&& (aux->pedido.conexion_pfs_id == structObtenido.conexion_pfs_id) && (aux->pedido.lectura_o_escritura == structObtenido.lectura_o_escritura)
				&& (comparacion_string == 0))) {  /* Encontrado */
			if (anterior == NULL) {

				*lst = aux->siguiente;
				if((colaPedidos->frente) == aux){

					if(colaPedidos->frente == colaPedidos->fin)
						colaPedidos->fin=colaPedidos->frente->siguiente;
					colaPedidos->frente=colaPedidos->frente->siguiente;
				}

			} else {

				anterior->siguiente = aux->siguiente;
				if((colaPedidos->fin) == aux){
					colaPedidos->fin=anterior;
				}
			}

			free(aux);

			return;
		}
	}

}
